Vad gör "använd strikt" i JavaScript, och vad är resonemanget bakom det?

Den här artikeln om Javascript Strict Mode kan intressera dig: John Resig - ECMAScript 5 Strict Mode, JSON och mer
För att citera några intressanta delar:
Strikt läge är en ny funktion i ECMAScript 5 som låter dig placera ett program eller en funktion i ett "strikt" driftläge. Detta strikta sammanhang förhindrar att vissa åtgärder vidtas och ger fler undantag.
Och:
Strikt läge hjälper till på ett par sätt:
Det fångar några vanliga kodande bloopers, vilket ger undantag.
Det förhindrar eller kastar fel när relativt "osäkra" åtgärder vidtas (som att få tillgång till det globala objektet).
Det inaktiverar funktioner som är förvirrande eller dåligt genomtänkta.
Observera också att du kan använda "strikt läge" på hela filen ... Eller så kan du bara använda den för en viss funktion (fortfarande citerar från John Resigs artikel):
// Icke-strikt kod ...
(fungera(){
"använd strikt";
// Definiera ditt bibliotek strikt ...
}) ();
// Icke-strikt kod ...
Vilket kan vara till hjälp om du måste blanda gammal och ny kod ;-)
Så jag antar att det är lite som "använd strikt" du kan använda i Perl (därav namnet?): Det hjälper dig att göra färre fel genom att upptäcka fler saker som kan leda till brott.
Strikt läge stöds nu av alla större webbläsare.
Inuti inbyggda ECMAScript-moduler (med import- och exportuttalanden) och ES6-klasser är strikt läge alltid aktiverat och kan inte inaktiveras.
|
Det är en ny funktion i ECMAScript 5. John Resig skrev upp en fin sammanfattning av den.
Det är bara en sträng som du lägger i dina JavaScript-filer (antingen högst upp i filen eller inuti en funktion) som ser ut så här:
"använd strikt";
Att lägga in det i din kod nu bör inte orsaka några problem med nuvarande webbläsare eftersom det bara är en sträng. Det kan orsaka problem med din kod i framtiden om din kod bryter mot pragma. Till exempel, om du för närvarande har foo = "bar" utan att definiera foo först, kommer din kod att misslyckas ... vilket enligt min mening är bra.
|
Uttalandet "använd strikt"; instruerar webbläsaren att använda strikt läge, vilket är en reducerad och säkrare funktioner för JavaScript.
Lista över funktioner (icke uttömmande)
Tillåter inte globala variabler. (Fångar saknade vardeklarationer och skrivfel i variabelnamn)
Tyst misslyckade uppdrag kastar fel i strikt läge (tilldelar NaN = 5;)
Försök att ta bort egenskaper som inte kan raderas slänger (ta bort Object.prototype)
Kräver att alla fastighetsnamn i ett objekt bokstavligen är unika (var x = {x1: "1", x1: "2"})
Funktionsparameternamn måste vara unika (funktionssumma (x, x) {...})
Förbjuder oktal syntax (var x = 023; vissa devs antar fel att en föregående noll inte gör något för att ändra antalet.)
Förbjuder nyckelordet
eval i strikt läge introducerar inte nya variabler
Förbjuder att ta bort vanliga namn (ta bort x;)
Förbjuder bindning eller tilldelning av namnvärden och argument i vilken form som helst
Strikt läge har inte alias för argumentens objekt med de formella parametrarna. (dvs. i funktionssumman (a, b) {returnerar argument [0] + b;} Detta fungerar eftersom argument [0] är bundna till a och så vidare.)
argument.callee stöds inte
[Ref: Strikt läge, Mozilla Developer Network]
|
Om människor är oroliga för att använda strikt användning kan det vara värt att kolla in den här artikeln:
ECMAScript 5 'Strikt läge' stöd i webbläsare. Vad betyder detta? NovoGeek.com - Krishnas weblog
Det talar om webbläsarstöd, men ännu viktigare hur man hanterar det säkert:
funktionen isStrictMode () {
återvänd! detta;
}
/ *
returnerar falskt, eftersom "detta" avser globalt objekt och
'! detta' blir falskt
* /
funktion isStrictMode () {
"använd strikt";
återvänd! detta;
}
/ *
returnerar sant, eftersom i strikt läge kommer nyckelordet 'detta'
hänvisar inte till globalt objekt, till skillnad från traditionell JS.
Så här, 'detta' är 'odefinierat' och '! Detta' blir sant.
* /
|
Ett försiktighetsord, alla hårdladdande programmerare: att använda "använd strikt" på befintlig kod kan vara farligt! Den här saken är inte något bra, glatt ansikts-klistermärke som du kan slå på koden för att göra den "bättre". Med "använd strikt" pragma, kastar webbläsaren plötsligt undantag på slumpmässiga platser som den aldrig kastade tidigare bara för att du på det stället gör något som standard / förlorar JavaScript med glädje men strikt JavaScript avskyr! Du kan ha stränghetsbrott som gömmer sig i sällan använda samtal i din kod som bara ger ett undantag när de så småningom körs - säg i den produktionsmiljö som dina betalande kunder använder!
Om du ska ta steget är det en bra idé att använda "använd strikt" vid sidan av omfattande enhetstester och en strikt konfigurerad JSHint-bygguppgift som ger dig lite förtroende för att det inte finns något mörkt hörn i din modul som kommer att spränga hemskt bara för att du har aktiverat Strikt läge. Eller hej, här är ett annat alternativ: lägg bara inte till "använd strikt" till någon av dina äldre koder, det är nog säkrare på det sättet, ärligt talat. DEFINITIVT Lägg INTE "använd strikt" till några moduler som du inte äger ellerunderhålla, som moduler från tredje part.
Jag tror att även om det är ett dödligt bur djur kan "använda strikt" vara bra grejer, men du måste göra det rätt. Den bästa tiden att gå strikt är när ditt projekt är greenfield och du börjar från grunden. Konfigurera JSHint / JSLint med alla varningar och alternativ som är så täta som ditt team kan mage, få ett bra system för att bygga / testa / hävda att du är riggad som Grunt + Karma + Chai, och bara börja sedan markera alla dina nya moduler som " använd strikt ". Var beredd att bota massor av niggly fel och varningar. Se till att alla förstår allvaret genom att konfigurera byggnaden till FAIL om JSHint / JSLint ger några överträdelser.
Mitt projekt var inte ett greenfield-projekt när jag antog "använd strikt". Som ett resultat är min IDE full av röda märken eftersom jag inte har "använda strikt" på halva mina moduler, och JSHint klagar över det. Det är en påminnelse till mig om vilken refactoring jag ska göra i framtiden. Mitt mål är att vara rött märkesfritt på grund av alla mina saknade "använd strikta" uttalanden, men det är år borta nu.
|
Använda 'använd strikt'; gör inte din kod plötsligt bättre.
JavaScript-strikt läge är en funktion i ECMAScript 5. Du kan aktivera strikt läge genom att förklara detta högst upp i ditt skript / funktion.
'använd strikt';
När en JavaScript-motor ser detta direktiv kommer den att börja tolka koden i ett speciellt läge. I det här läget kastas fel upp när vissa kodningsmetoder som kan bli potentiella buggar upptäcks (vilket är resonemanget bakom det strikta läget).
Tänk på detta exempel:
var a = 365;
var b = 030;
I sin besatthet att ställa upp de numeriska bokstäverna har utvecklaren av misstag initierat variabel b med en oktal bokstav. Icke-strikt läge tolkar detta som en numerisk bokstav med värdet 24 (i bas 10). Men strikt läge kommer att orsaka ett fel.
För en icke-uttömmande lista över specialiteter i strikt läge, se detta svar.
Var ska jag använda "använd strikt" ;?
I min nya JavaScript-applikation: Absolut! Strikt läge kan användas som en visselblåsare när du gör något dumt med din kod.
I min befintliga JavaScript-kod: Förmodligen inte! Om din befintliga JavaScript-kod har uttalanden som är förbjudna i strikt läge kommer applikationen helt enkelt att brytas. Om du vill ha strikt läge bör du vara beredd att felsöka och korrigera din befintliga kod. Det är därför som använder "använd strikt"; gör inte din kod plötsligt bättre.
Hur använder jag strikt läge?
Infoga en "använd strikt"; uttalande ovanpå ditt manus:
// Fil: myscript.js
'använd strikt';
var a = 2;
....
Observera att allt i filen myscript.js tolkas i strikt läge.
Eller infoga en "använd strikt"; uttalande ovanpå din funktionskropp:
funktion doSomething () {
'använd strikt';
...
}
Allt i det lexikala funktionsomfånget doNething kommer att tolkas i strikt läge. Ordet lexikaliskt omfång är viktigt här. Till exempel, om din strikta kod anropar en funktion i ett bibliotek som inte är strikt, körs bara din kod i strikt läge och inte den anropade funktionen. Se detta svar för en bättre förklaring.
Vilka saker är förbjudna i strikt läge?
Jag hittade en trevlig artikel som beskriver flera saker som är förbjudna i strikt läge (notera att detta inte är en exklusiv lista):
Omfattning
Historiskt har JavaScript varit förvirrad över hur funktionerna fungerar
är omfattade. Ibland verkar de vara statiskt räckvidd, men vissa
funktioner gör att de beter sig som de är dynamiskt omfattade. Detta är
förvirrande, vilket gör program svåra att läsa och förstå.
Missförstånd orsakar buggar. Det är också ett problem för prestanda.
Statisk räckvidd möjliggör variabel bindning vid sammanställning
tid, men kravet på dynamiskt omfång innebär att bindningen måste vara
uppskjuten till körtid, vilket kommer med en betydande prestanda
straff.
Strikt läge kräver att all variabel bindning görs statiskt.
Det betyder att de funktioner som tidigare krävde dynamisk bindning
måste elimineras eller modifieras. Specifikt är det med uttalandet
elimineras, och eval funktionens förmåga att manipulera med
uppringarens miljö är kraftigt begränsad.
En av fördelarna med strikt kod är att verktyg som YUI Compressor
kan göra ett bättre jobb när de bearbetar det.
Underförstådda globala variabler
JavaScript har inneburit globala variabler. Om
du förklarar inte uttryckligen en variabel, en global variabel är
implicit förklaras åt dig. Detta gör programmeringen enklare för
nybörjare eftersom de kan försumma en del av sin grundläggande städning
sysslor. Men det gör hanteringen av större program mycket mer
svårt och försämrar betydligt tillförlitligheten. Så strikt
läge skapas inte längre underförstådda globala variabler. Du borde
förklara uttryckligen alla dina variabler.
Global läckage
Det finns ett antal situationer som kan orsaka detta
att vara bunden till det globala objektet. Till exempel om du glömmer att
ange det nya prefixet när du ringer till en konstruktörfunktion, den
konstruktörens detta kommer oväntat att vara bundet till det globala objektet, så
istället för att initialisera ett nytt objekt kommer det istället att vara tyst
manipulera med globala variabler. I dessa situationer kommer strikt läge att
istället binda detta till odefinierat, vilket kommer att få konstruktören att
kasta ett undantag istället, så att felet kan upptäckas mycket
förr.
Bullrigt misslyckande
JavaScript har alltid haft skrivskyddade egenskaper, men du
kunde inte skapa dem själv förrän ES5: s Object.createProperty
funktion exponerade den förmågan. Om du försökte tilldela ett värde
till en skrivskyddad egendom skulle den misslyckas tyst. Uppdraget skulle
ändra inte fastighetens värde, men ditt program fortsätter som
även om det hade. Detta är en integritetsrisk som kan orsaka program
gå in i ett inkonsekvent tillstånd. I strikt läge försöker du ändra en
skrivskyddad egendom ger ett undantag.
Octal
Den oktala (eller bas 8) representationen av tal var extremt
användbart när du gör programmering på maskinnivå på maskiner vars ord
storlekar var en multipel av 3. Du behövde oktal när du arbetar med CDC
6600 mainframe, som hade en ordstorlek på 60 bitar. Om du kunde läsa
oktalt, kan du titta på ett ord som 20 siffror. Två siffror representerade
op-koden och en siffra identifierade ett av åtta register. Under
långsam övergång från maskinkoder till högnivåspråk var det
anses vara användbart för att tillhandahålla oktala former på programmeringsspråk.
I C var en extremt olycklig representation av oktalitet
vald: Ledande noll. Så i C betyder 0100 64, inte 100, och 08 är ett
fel, inte 8. Ännu mer tyvärr har denna anakronism varit
kopieras till nästan alla moderna språk, inklusive JavaScript, var
den används bara för att skapa fel. Det har inget annat syfte. Så in
strikt läge är oktala former inte längre tillåtna.
Etc
Argumenten pseudo array blir lite mer
arrayliknande i ES5. I strikt läge förlorar den sin callee och ringer
egenskaper. Detta gör det möjligt att skicka dina argument till otillförlitliga
utan att ge upp mycket konfidentiellt sammanhang. Även
argumentegenskaper för funktioner elimineras.
I strikt läge kommer dubbla nycklar i en funktionslitteratur att producera en
syntaxfel. En funktion kan inte ha två parametrar med samma namn.
En funktion kan inte ha en variabel med samma namn som en av dess
parametrar. En funktion kan inte radera sina egna variabler. Ett försök att
ta bort en icke-konfigurerbar egenskap ger nu ett undantag. Primitiv
värdena är inte implicit inslagna.
Reserverade ord för framtida JavaScript-versioner
ECMAScript 5 lägger till en lista med reserverade ord. Om du använder dem som variabler eller argument kommer strikt läge att orsaka ett fel. De reserverade orden är:
implementerar, gränssnitt, låt, paketera, privat, skyddat, offentligt, statiskt och avkastning
Vidare läsning
Strikt läge - JavaScript | MDN
Webbläsarstöd för strikt läge
Övergång till strikt läge
|
Jag rekommenderar alla utvecklare att börja använda strikt läge nu. Det finns tillräckligt många webbläsare som stöder det för att strikt läge legitimt kan hjälpa till att rädda oss från fel som vi inte ens visste fanns i din kod.
Tydligen kommer det att finnas fel som vi aldrig har stött på i början. För att få full nytta måste vi göra ordentliga tester efter att ha bytt till strikt läge för att se till att vi har fått allt. Definitivt kastar vi inte bara sträng användning i vår kod och antar att det inte finns några fel. Så churn är att det är dags att börja använda denna otroligt användbara språkfunktion för att skriva bättre kod.
Till exempel,
var person = {
namn: 'xyz',
position: 'abc',
fullnamn: funktion () {"använd strikt"; returnera detta.namn; }
};
JSLint är en debugger skriven av Douglas Crockford. Klistra bara in ditt skript så söker det snabbt efter märkbara problem och fel i din kod.
|
Jag skulle vilja erbjuda ett något mer grundat svar som kompletterar de andra svaren. Jag hoppades kunna redigera det mest populära svaret men misslyckades. Jag försökte göra det så omfattande och komplett som möjligt.
Mer information finns i MDN-dokumentationen.
"använd strikt" ett direktiv som införts i ECMAScript 5.
Direktiven liknar uttalanden, men ändå olika.
använd strikt innehåller inte nyckelord: Direktivet är ett enkelt uttrycksuttalande, som består av en speciell sträng bokstavlig (i enkla eller dubbla citat). JavaScript-motorer, som inte implementerar ECMAScript 5, ser bara ett uttrycksuttalande utan biverkningar. Det förväntas att framtida versioner av ECMAScript-standarder introducerar användning som ett verkligt nyckelord; citaten skulle därmed bli föråldrade.
använd strikt kan endast användas i början av ett skript eller en funktion, dvs. det måste föregå alla andra (riktiga) uttalanden. Det behöver inte vara den första instruktionen i ett funktionsmanuskript: det kan föregås av andra uttalandeuttryck som består av stränglitteraler (och JavaScriptimplementeringar kan behandla dem som specifika implementeringsdirektiv). Stränglitterära uttalanden, som följer ett första riktigt uttalande (i ett skript eller en funktion) är enkla uttrycksuttryck. Tolkar får inte tolka dem som direktiv och de har ingen effekt.
Användningsstriktdirektivet anger att följande kod (i ett skript eller en funktion) är strikt kod.
Koden på den högsta nivån i ett skript (kod som inte finns i en funktion) anses vara strikt kod när skriptet innehåller ett användningsstrikt direktiv.
Innehållet i en funktion anses vara strikt kod när själva funktionen definieras i en strikt kod eller när funktionen innehåller ett strikt användningsdirektiv.
Kod som skickas till en eval () -metod anses vara strikt kod när eval () anropades från en strikt kod eller innehåller själva användningsstrikt direktivet.
Det strikta läget för ECMAScript 5 är en begränsad delmängd av JavaScript-språket, vilket eliminerar relevanta brister i språket och har strängare felkontroll och högre säkerhet. Följande listar skillnaderna mellan strikt läge och normalt läge (varav de tre första är särskilt viktiga):
Du kan inte använda with-statement i strikt läge.
I strikt läge måste alla variabler deklareras: om du tilldelar ett värde till en identifierare som inte har deklarerats som variabel, funktion, funktionsparameter, catch-clause-parameter eller egenskap för det globala objektet, får du en ReferenceError. I normalt läge förklaras identifieraren implicit som en global variabel (som en egenskap för det globala objektet)
I strikt läge har nyckelordet detta värdet odefinierat i funktioner som åberopats som funktioner (inte som metoder). (I normalt läge pekar detta alltid på det globala objektet). Denna skillnad kan användas för att testa om en implementering stöder det strikta läget:
var hasStrictMode = (funktion () {"använd strikt"; returnera detta === undefined} ());
Även när en funktion anropas med call () eller tillämpas i strikt läge, är detta exakt värdet på det första argumentet för samtalet () eller applicera (). (I normalt läge ersätts null och odefinierad med det globala objektet och värden, som inte är objekt, kastas till objekt.)
I strikt läge får du en TypeError när du försöker tilldela till enbart egenskaper eller att definiera nya egenskaper för ett icke utdragbart objekt. (I normalt läge misslyckas båda helt enkelt utan felmeddelande.)
I strikt läge, när du skickar kod till eval (), kan du inte deklarera eller definiera variabler eller funktioner i den som ringer (som du kan göra det i normalt läge). Istället skapas ett nytt omfång för eval () och variablerna och funktionerna ligger inom detta omfång. Det omfattningen förstörs efter att eval () slutfört körningen.
I strikt läge innehåller argument-objektet för en funktion en statisk kopia av värdena som skickas till den funktionen. I normalt läge har argument-objektet något "magiskt" beteende: Elementen i matrisen och de angivna funktionsparametrarna refererar till båda samma värde.
I strikt läge får du en SyntaxError när borttagningsoperatören följs av en icke-kvalificerad identifierare (en variabel, funktion eller funktionsparameter). I normalt läge skulle borttagningsuttrycket inte göra någonting och utvärderas till falskt.
I strikt läge får du en TypeError när du försöker ta bort en ej konfigurerbar egenskap. (I normalt läge misslyckas helt enkelt försöket och borttagningsuttrycket utvärderas till falskt).
I strikt läge anses det vara ett syntaktiskt fel när du försöker definiera flera egenskaper med samma namn för ett objekt bokstavligt. (I normalt läge är det inget fel.)
I strikt läge anses det vara ett syntaktiskt fel när en funktionsdeklaration har flera parametrar med samma namn. (I normalt läge är det inget fel.)
I strikt läge är oktala bokstäver inte tillåtna (dessa är bokstäver som börjar med 0x. (I normalt läge tillåter vissa implementeringar oktala bokstäver.)
I strikt läge behandlas identifieringseval och argument som nyckelord. Du kan inte ändra deras värde, inte tilldela ett värde till dem och du kan inte använda dem som namn för variabler, funktioner, funktionsparametrar eller identifierare för ett fångstblock.
I strikt läge finns fler begränsningar för möjligheterna att undersöka samtalsstacken. argument.caller och argument.callee orsakar en TypeError i en funktion i strikt läge. Dessutom orsakar vissa funktioner för samtal och argument för funktioner i strikt läge en TypeError när du försöker läsa dem.
|
Mina två cent:
Ett av målen med strikt läge är att möjliggöra snabbare felsökning av problem. Det hjälper utvecklarna genom att kasta undantag när vissa felaktiga saker inträffar som kan orsaka tyst och konstigt beteende på din webbsida. I det ögonblick vi använder strikt kommer koden att kasta bort fel som hjälper utvecklare att fixa det i förväg.
Få viktiga saker som jag har lärt mig efter att ha använt strikt:
Förhindrar global variabeldeklaration:
var tree1Data= {namn: 'Bananträd', ålder: 100, leafCount: 100000};
funktionsträd (typeOfTree) {
var ålder;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = nytt träd (tree1Data);
console.log (fönster);
Nu skapar den här koden namnetree i global omfattning som kan nås med hjälp av window.nameoftree. När vi implementerar använd strikt skulle koden orsaka fel.
Uncaught ReferenceError: nameoftree är inte definierat
Prov
Elimineras med uttalande:
med uttalanden kan inte minifieras med hjälp av verktyg som uglify-js. De är också utfasade och tas bort från framtida JavaScript-versioner.
Prov
Förhindrar duplikat:
När vi har duplicerad egendom, ger det ett undantag
Uncaught SyntaxError: Duplicera dataegenskap i objektet bokstavligen inte
tillåtet i strikt läge
"använd strikt";
var tree1Data = {
namn: 'Bananträd',
ålder: 100,
leafCount: 100000,
namn: 'Bananträd'
};
Det finns få fler men jag behöver få mer kunskap om det.
|
Om du använder en webbläsare som släpptes under det senaste året eller så stöder den troligen JavaScript Strict-läge. Endast äldre webbläsare innan ECMAScript 5 blev den nuvarande standarden stöder det inte.
Citaten runt kommandot ser till att koden fortfarande fungerar i äldre webbläsare (även om de saker som genererar ett syntaxfel i strikt läge i allmänhet bara orsakar att skriptet inte fungerar på något svårt att upptäcka sätt i de äldre webbläsarna).
|
När du lägger till "använd strikt"; kommer följande fall att kasta en SyntaxError innan skriptet körs:
Bana väg för framtida ECMAScript-versioner med ett av de nyligen reserverade nyckelorden (i förväg för ECMAScript 6): redskap, gränssnitt, låt, paketera, privat, skyddat, offentligt, statiskt och avkastning.
Deklareringsfunktion i block
om (a : 3: 15)
vid : 6: 5
Här kastar kompilatorn referensfelet. I strikt läge tillåter inte kompilatorn att vi använder variabeln utan att deklarera den. Så minnesläckor kan förhindras. Dessutom kan vi skriva mer optimerad kod.
|
Strikt läge eliminerar fel som skulle ignoreras i icke-strikt läge, vilket gör javascript "säkrare".
Anses det bland bästa praxis?
Ja, det anses vara en del av de bästa metoderna när du arbetar med javascript för att inkludera Strikt läge. Detta görs genom att lägga till nedanstående kodrad i din JS-fil.
'använd strikt';
i din kod.
Vad betyder det för användaragenter?
Att ange att koden ska tolkas i strikt läge anger för användaragenter som webbläsare att de ska behandla koden bokstavligen som skrivna och kasta ett fel om koden inte är vettig.
Till exempel: Tänk på att i din .js-fil har du följande kod:
Scenario 1: [NO STRICT MODE]
var city = "Chicago"
console.log (city) // Skriver ut stadens namn, dvs. Chicago
Scenario 2: [NO STRICT MODE]
stad = "Chicago"
console.log (city) // Skriver ut stadens namn, dvs. Chicago
Så varför skrivs variabelnamnet ut i båda fallen?
Utan att strikt läge är aktiverat går användaragenter ofta igenom en serie modifieringar av problematisk kod i ett försök att få det att ge mening. På ytan kan detta verka som en bra sak, och det är faktiskt att arbeta utanför det strikta läget som gör det möjligt för människor att få fötterna blöta med JavaScript-kod utan att alla detaljer är ganska spikade. Men som utvecklare vill jag inte lämna ett fel i min kod, för jag vet att det kan komma tillbaka och bita mig senare, och jag vill också bara skriva bra kod. Och det är där strikt läge hjälper till.
Scenario 3: [STRICT MODE]
'använd strikt';
stad = "Chicago"
console.log (city) // Referensfel: asignment är odeklarerad variabel stad.
Ytterligare tips: För att upprätthålla kodkvaliteten i strikt läge behöver du inte skriva detta om och om igen, särskilt om du har flera .js-filer. Du kan tillämpa denna regel globalt i eslint-regler enligt följande:
Filnamn: .eslintrc.js
module.exports = {
env: {
es6: sant
},
regler: {
strikt: ['error', 'global'],
},
};
Okej, så vad förhindras i strikt läge?
Att använda en variabel utan att deklarera kommer att kasta ett fel i strikt läge. Detta för att förhindra att oavsiktligt skapa globala variabler i hela din applikation. Exemplet med utskrift av Chicago täcker särskilt detta.
Att ta bort en variabel eller en funktion eller ett argument är ett nej-nej i strikt läge.
"använd strikt";
funktion x (p1, p2) {};
ta bort x; // Detta kommer att orsaka ett fel
Duplicering av ett parameternamn är inte tillåtet i strikt läge.
"använd strikt";
funktion x (p1, p1) {}; // Detta kommer att orsaka ett fel
Reserverade ord på Javascript-språket är inte tillåtna i strikt läge. Orden är implementeringsgränssnitt, låt, paket, privat, skyddat, offentligt. statisk och avkastning
För en mer omfattande lista, se MDN-dokumentationen här: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Mycket aktiv fråga. Tjäna 10 rykte för att svara på den här frågan. Kravet på rykte hjälper till att skydda denna fråga från skräppost och icke-svar-aktivitet.
Inte svaret du letar efter? Bläddra bland andra frågor taggade javascript syntax jslint använd-strikt eller ställ din egen fråga.